home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / MATH / MFLOAT10.ZIP / MFLOAT.CXX < prev    next >
C/C++ Source or Header  |  1993-04-28  |  10KB  |  191 lines
  1. #ifndef mfloat_cxx
  2. #define mfloat_cxx
  3.  
  4. #include "mfloat.h"
  5. #include <iomanip.h>
  6. #include <math.h>
  7. #pragma intrinsic -fabs
  8. #undef mfloat
  9.  
  10. class mfloat {
  11. #define fmo friend mfloat operator
  12. #define fro friend mfloat& operator
  13. #define fbo friend char operator
  14.    public:
  15.      mfloat()                                 { mf[0] = 0; }
  16.      mfloat(const mfloat &a)                  { equm(this->mf,a.mf); }
  17.      mfloat(const long double a)              { ldtomf(this->mf,a); }
  18.  
  19.      mfloat& operator = (const mfloat &a)     { equm(this->mf,a.mf); return(*this); }
  20.  
  21.      fmo + (const mfloat &a)                { return(a); }
  22.  
  23.      fro ++ (mfloat &a)      /*prefix*/       { addm(a.mf,onem); return(a); }
  24.      fmo ++ (mfloat &a,int)  /*suffix*/       { mfloat t; equm(t.mf,a.mf); addm(a.mf,onem); return(t); }
  25.  
  26.      fro -- (mfloat &a)      /*prefix*/       { subm(a.mf,onem); return(a); }
  27.      fmo -- (mfloat &a,int)  /*suffix*/       { mfloat t; equm(t.mf,a.mf); subm(a.mf,onem); return(t); }
  28.  
  29.      fmo - (mfloat a)                      { negm(a.mf); return(a); }
  30.  
  31.      fmo + (mfloat a, const mfloat &b)        { addm(a.mf,b.mf); return(a); }
  32.  
  33.      fro += (mfloat &a, const mfloat &b)      { addm(a.mf,b.mf); return(a); }
  34.  
  35.      fmo - (mfloat a, const mfloat &b)        { subm(a.mf,b.mf); return(a); }
  36.  
  37.      fro -= (mfloat &a, const mfloat &b)      { subm(a.mf,b.mf); return(a); }
  38.  
  39.      fmo * (mfloat a, const mfloat &b)        { multm(a.mf,b.mf); return(a); }
  40.      fmo * (mfloat a, const unsigned int b)   { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  41.      fmo * (mfloat a, const int b)            { multi(a.mf,b); return(a); }
  42.      fmo * (mfloat a, const unsigned long b)  { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  43.      fmo * (mfloat a, const long b)           { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  44.      fmo * (mfloat a, const double b)         { mfloata t; multm(a.mf,dtomf(t,b)); return(a); }
  45.      fmo * (mfloat a, const long double b)    { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  46.      fmo * (const unsigned int b   ,mfloat a) { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  47.      fmo * (const int b            ,mfloat a) { multi(a.mf,b); return(a); }
  48.      fmo * (const unsigned long b  ,mfloat a) { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  49.      fmo * (const long b           ,mfloat a) { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  50.      fmo * (const double b         ,mfloat a) { mfloata t; multm(a.mf,dtomf(t,b)); return(a); }
  51.      fmo * (const long double b    ,mfloat a) { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  52.  
  53.      fro *= (mfloat &a, const mfloat &b)       { multm(a.mf,b.mf); return(a); }
  54.      fro *= (mfloat &a, const unsigned int b)  { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  55.      fro *= (mfloat &a, const int b)           { multi(a.mf,b); return(a); }
  56.      fro *= (mfloat &a, const unsigned long b) { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  57.      fro *= (mfloat &a, const long b)          { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  58.      fro *= (mfloat &a, const double b)        { mfloata t; multm(a.mf,dtomf(t,b)); return(a); }
  59.      fro *= (mfloat &a, const long double b)   { mfloata t; multm(a.mf,ldtomf(t,b)); return(a); }
  60.  
  61.      fmo / (mfloat a, const mfloat &b)        { divm(a.mf,b.mf); return(a); }
  62.      fmo / (mfloat a, const unsigned int b)   { mfloata t; divm(a.mf,ldtomf(t,b)); return(a); }
  63.      fmo / (mfloat a, const int b)            { divi(a.mf,b); return(a); }
  64.      fmo / (mfloat a, const unsigned long b)  { mfloata t; divm(a.mf,ldtomf(t,b)); return(a); }
  65.      fmo / (mfloat a, const long b)           { mfloata t; divm(a.mf,ldtomf(t,b)); return(a); }
  66.      fmo / (mfloat a, const double b)         { mfloata t; divm(a.mf,dtomf(t,b)); return(a); }
  67.      fmo / (mfloat a, const long double b)    { mfloata t; divm(a.mf,ldtomf(t,b)); return(a); }
  68.  
  69.      fro /= (mfloat &a, const mfloat &b)        { divm(a.mf,b.mf); return(a); }
  70.      fro /= (mfloat &a, const unsigned int b)   { mfloata t; divm(a.mf,ldtomf(t,b)); return(a); }
  71.      fro /= (mfloat &a, const int b)            { divi(a.mf,b); return(a); }
  72.      fro /= (mfloat &a, const unsigned long b)  { mfloata t; divm(a.mf,ldtomf(t,b)); return(a); }
  73.      fro /= (mfloat &a, const long b)           { mfloata t; divm(a.mf,ldtomf(t,b)); return(a); }
  74.      fro /= (mfloat &a, const double b)         { mfloata t; divm(a.mf,dtomf(t,b)); return(a); }
  75.      fro /= (mfloat &a, const long double b)    { mfloata t; divm(a.mf,ldtomf(t,b)); return(a); }
  76.  
  77.      fbo <  (const mfloat &a, const mfloat &b)   { return(gtm(b.mf,a.mf)); }
  78.      fbo >  (const mfloat &a, const mfloat &b)   { return(gtm(a.mf,b.mf)); }
  79.      fbo <= (const mfloat &a, const mfloat &b)   { return(!gtm(a.mf,b.mf)); }
  80.      fbo >= (const mfloat &a, const mfloat &b)   { return(!gtm(b.mf,a.mf)); }
  81.      fbo == (const mfloat &a, const mfloat &b)   { return(eqm(a.mf,b.mf)); }
  82.      fbo != (const mfloat &a, const mfloat &b)   { return(!eqm(a.mf,b.mf)); }
  83.  
  84.      friend ostream& operator<< (ostream& os, const mfloat &a);
  85.      friend istream& operator>> (istream& is, mfloat &a);
  86.  
  87.      /* basic functions */
  88.      friend int    strtomf(mfloat &a, const char *s) { return(strtomf_(a.mf,s,strlen(s))); }
  89.      friend char far * mftoa(char far * str, const mfloat &a, int len) { mftostr_(str,a.mf,&len,".32767F"); str[len]=0; return str; };
  90.      friend char far * mftostr(char far * str, const mfloat &a, int len, const char far * format) { mftostr_(str,a.mf,&len,format); str[len]=0; return str; };
  91.      friend double mftod(const mfloat &a)        { return(mftod(a.mf)); }
  92.      friend long double mftold(const mfloat &a)  { return(mftold(a.mf)); }
  93.      /* standard functions (Borland C: MATH.H */
  94.      friend mfloat acos(mfloat a)         { acosm(a.mf); return(a); }
  95.      friend mfloat asin(mfloat a)         { asinm(a.mf); return(a); }
  96.      friend mfloat atan(mfloat a)         { atanm(a.mf); return(a); }
  97.      friend mfloat atan2(mfloat a, const mfloat &b) { atan2m(a.mf, b.mf); return(a); }
  98. /*?*/friend mfloat atofm(const char *s)         { mfloat t; strtomf_(t.mf,s,strlen(s)); return(t); }
  99.      friend mfloat ceil(mfloat a)         { ceilm(a.mf); return(a); }
  100.      friend mfloat cos(mfloat a)         { cosm(a.mf); return(a); }
  101.      friend mfloat cosh(mfloat a)         { coshm(a.mf); return(a); }
  102.      friend mfloat exp(mfloat a)         { expm(a.mf); return(a); }
  103.      friend mfloat fabs(mfloat a)         { fabsm(a.mf); return(a); }
  104.      friend mfloat floor(mfloat a)         { floorm(a.mf); return(a); }
  105.      friend mfloat fmod(mfloat a, const mfloat &b) { fmodm(a.mf, b.mf); return(a); }
  106.      friend mfloat frexp(mfloat a, int *b)      { frexpm(a.mf,b); return(a); }
  107.      friend mfloat hypot(mfloat a, const mfloat &b) { hypotm(a.mf, b.mf); return(a); }
  108.      friend mfloat ldexp(mfloat a, int b)        { ldexpm(a.mf, b); return(a); }
  109.      friend mfloat log(mfloat a)         { logm(a.mf); return(a); }
  110.      friend mfloat log10(mfloat a)         { log10m(a.mf); return(a); }
  111.      friend mfloat modf(mfloat a, mfloat * b)    { modfm(a.mf, (*b).mf); return(a); }
  112.      friend mfloat pow(mfloat a, const mfloat &b){ powm(a.mf, b.mf); return(a); }
  113. /*?*/friend mfloat pow10m(int b)                  { mfloat a; pow10m(a.mf, b); return(a); }
  114.      friend mfloat sin(mfloat a)         { sinm(a.mf); return(a); }
  115.      friend mfloat sinh(mfloat a)         { sinhm(a.mf); return(a); }
  116.      friend mfloat sqrt(mfloat a)         { sqrtm(a.mf); return(a); }
  117.      friend mfloat tan(mfloat a)         { tanm(a.mf); return(a); }
  118.      friend mfloat tanh(mfloat a)         { tanhm(a.mf); return(a); }
  119. /* extended standard functions */
  120.      friend mfloat acosh(mfloat a)         { acoshm(a.mf); return(a); }
  121.      friend mfloat asinh(mfloat a)         { asinhm(a.mf); return(a); }
  122.      friend mfloat atanh(mfloat a)         { atanhm(a.mf); return(a); }
  123.      friend mfloat acot(mfloat a)         { acotm(a.mf); return(a); }
  124.      friend mfloat acoth(mfloat a)         { acothm(a.mf); return(a); }
  125.      friend mfloat cot(mfloat a)         { cotm(a.mf); return(a); }
  126.      friend mfloat coth(mfloat a)         { cothm(a.mf); return(a); }
  127.      friend mfloat exp10(mfloat a)         { exp10m(a.mf); return(a); }
  128.      friend mfloat sqr(mfloat a)         { sqrm(a.mf); return(a); }
  129.      friend mfloat trunc(mfloat a)         { truncm(a.mf); return(a); }
  130. //private:
  131.      mfloata mf;
  132.  
  133. #undef fmo
  134. #undef fro
  135. #undef fbo
  136. };
  137.  
  138. #define maxdigits (mfloatwords*24/5+8)
  139.  
  140. ostream& operator<< (ostream& os, const mfloat &a) {
  141.   char ch[maxdigits];
  142.   int len = maxdigits;
  143.   char format[10];
  144.   char * f = format;
  145.  
  146.   if (os.flags() & os.showpos)   *(f++) = '+';
  147.   if (os.flags() & os.showpoint) *(f++) = '.';
  148.  
  149.   f +=5;
  150.   int i = os.precision();
  151.   if (i <= 0) i = 6;
  152.   for (int j=0; j<5; j++) { *(--f) = i % 10 + '0'; i /= 10; }
  153.   f += 5;
  154.  
  155.   if      (os.flags() & os.fixed)      *f = 'f';
  156.   else if (os.flags() & os.scientific) *f = 'e';
  157.   else                                 *f = 'g';
  158.  
  159.   if (os.flags() & os.uppercase) *f -= 'a'-'A';
  160.   *(++f) = 0;
  161.  
  162.   mftostr_(ch,a.mf,&len,format);
  163.   ch[len] = 0;
  164.  
  165.   os << ch;
  166.  
  167.   return os;
  168. }
  169.  
  170. istream& operator>> (istream& is, mfloat &a) {
  171.   char ch[maxdigits];
  172.   int old = is.width(maxdigits);
  173.   is >> ch;
  174.   is.width(old);
  175.   if (ch[0] == 0) {
  176.     is.clear(ios::badbit | is.rdstate());
  177.     equm(a.mf,zerom);
  178.   }
  179.   else if (strtomf(a.mf,ch) != 0) {
  180.     is.clear(ios::failbit | is.rdstate());
  181.     equm(a.mf,zerom);
  182.   }
  183.   return(is);
  184. }
  185.  
  186. #undef maxdigits
  187.  
  188. const mfloat pi = 2 * acos((mfloat) 0);
  189.  
  190. #endif /* #ifndef mfloat_cxx */
  191.